package belf.migrate.core.util;

import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 补充apache common-lang的StringUtils之外的字符串方法
 */
public class StringTool {
    /**
     * 使用正则表达式替换输入字符串input中的target子串，替换为replacement
     * @param input 输入字符串
     * @param target 要查找的子串
     * @param replacement 要替换的子串
     * @param caseInSensitive 是否大小写不敏感
     * @return
     */
    public static String replaceAll(String input, String target, String replacement, boolean caseInSensitive) {
        // 创建忽略大小写的正则表达式模式

        Pattern pattern = caseInSensitive? Pattern.compile(target, Pattern.CASE_INSENSITIVE):Pattern.compile(target);
        Matcher matcher = pattern.matcher(input);

        // 进行替换
        String replacedString = matcher.replaceAll(replacement);
        return replacedString;
    }

    public static String removeDoubleQuotes(String input) {
        if (null == input) {
            return input;
        }

        // 检查字符串是否以双引号开头和结尾
        if (input.startsWith("\"") && input.endsWith("\"")) {
            // 去掉两端的双引号
            return input.substring(1, input.length() - 1);
        }

        // 检查字符串是否以单引号开头和结尾
        if (input.startsWith("'") && input.endsWith("'\"'")) {
            // 去掉两端的单引号
            return input.substring(1, input.length() - 1);
        }

        return input;
    }

    /**
     * 字符串input是否以指定的引号开始和结尾
     * @param input 输入字符串
     * @param quote 引号格式
     * @return
     */
    public static boolean hasQuote(String input, String quote) {
        if (StringUtils.isEmpty(input)) return false;
        if (StringUtils.isEmpty(quote)) return false;

        return input.startsWith(quote) && input.endsWith(quote);
    }

    /**
     * 给输入字符串input加上指定的引号。如果input本身已经有quote了，不做改变
     * @param input 输入字符串
     * @param quote 引号格式
     * @return
     */
    public static String addQuote(String input, String quote) {
        if (hasQuote(input, quote)) return input;

        if (StringUtils.isEmpty(input)) return input;
        if (StringUtils.isEmpty(quote)) return input;

        return quote + input + quote;
    }

    /**
     * 去掉字符串两边的圆括号。在Source表转化为Sink表时，去掉字段的默认值两边的圆括号。例如：
     * <ul>
     * <li>((0))  -->  0</li>
     * <li>(getdate()) -->  getdate()</li>
     * </ul>
     * @param input
     * @return
     */
    public static String trimParentheses(String input) {
        if (input == null || input.length() < 2) {
            return input;
        }

        int i = 0;
        int j = input.length() - 1;
        boolean found = false;
        while (input.charAt(i) == '(' && input.charAt(j) == ')' && i < j) {
            i++;
            j--;
            found = true;
        }
        if (found) {
            j++;  //String.substring(fromIndex, toIndex)，要求toIndex在要截取字符的下一个下标
        }
        if (found && i < j) {
            return input.substring(i, j);
        }
        return input;
    }

    /**
     * 查找字段默认值中的函数名称，用于后续查找Sink端的替代函数名称
     * @param value 从Source端查到的字段的默认值
     * @return 返回有效函数，或者返回空字符串
     */
    public static String getFunctionName(String value) {
        if (StringUtils.isEmpty(value)) {
            return "";
        }

        if (value.contains("(") && value.endsWith(")")) {
            int loc = value.indexOf('(');
            return value.substring(0, loc);
        }
        return value;
    }

    /**
     * 去掉输入字符串中的几个特定字符
     * @param input 输入字符串
     * @param charsToRemove 要删除的字符集合
     * @return
     */
    public static String removeChars(String input, String charsToRemove) {
        StringBuilder sb = new StringBuilder();
        for (char ch : input.toCharArray()) {
            if (!charsToRemove.contains(String.valueOf(ch))) {
                sb.append(ch);
            }
        }
        return sb.toString();
    }

    /**
     * 从输入字符串input中提取第一个left子串之后、left后第一个right子串之前的字符串
     * @param input
     * @param left
     * @param right
     * @return
     */
    public static String substring(String input, String left, String right) {
        int first = input.indexOf(left);
        if (first < 0) {
            return input;
        }

        int end = input.indexOf(right, first + left.length());
        if (end < 0) {
            return input;
        }

        return input.substring(first + left.length(), end);
    }

    public static String substring(String input, String subStr) {
        int index = input.indexOf(subStr);
        if (index < 0) {
            return input;
        }
        return input.substring(index + subStr.length());
    }

    /**
     * 查找输入字符串input最后一个子串subStr之后的部分，包含最后的subStr
     * @param input
     * @param subStr
     * @return
     */
    public static String lastSubstring(String input, String subStr) {
        int index = input.lastIndexOf(subStr);
        if (index < 0) {
            return input;
        }
        return input.substring(index + subStr.length());
    }

    /**
     * 删除输入字符串input末尾的子串last。input必须是以last结束的，才删除last
     * @param input 输入字符串
     * @param last 最右侧的子串
     * @return
     */
    public static String trimRight(String input, String last) {
        if (input.endsWith(last)) {
            int index = input.lastIndexOf(last);
            return input.substring(0, index);
        }
        return input;
    }
}
